package controllers

import (
	"encoding/json"
	"strconv"
	"supershare/backend/middleware"
	"supershare/backend/models"

	"github.com/beego/beego/v2/server/web"
)

// DeviceGroupController 设备分组控制器
type DeviceGroupController struct {
	web.Controller
}

// List 获取设备分组列表
func (c *DeviceGroupController) List() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分页参数
	pageStr := c.GetString("page")
	pageSizeStr := c.GetString("pageSize")

	page := 1
	pageSize := 10

	if pageStr != "" {
		page, _ = strconv.Atoi(pageStr)
	}

	if pageSizeStr != "" {
		pageSize, _ = strconv.Atoi(pageSizeStr)
	}

	// 构建查询条件
	filters := make(map[string]interface{})

	// 关键词搜索
	keyword := c.GetString("name")
	if keyword != "" {
		filters["keyword"] = keyword
	}

	// 加盟商权限过滤
	if permResult.Admin.FranchiseId > 0 {
		filters["franchise_id"] = permResult.Admin.FranchiseId
	}

	// 获取设备分组列表
	groups, total, err := models.GetDeviceGroupList(page, pageSize, filters)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备分组列表失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取设备分组列表成功",
		"data": map[string]interface{}{
			"data":  groups,
			"total": total,
		},
	}
	c.ServeJSON()
}

// Detail 获取设备分组详情
func (c *DeviceGroupController) Detail() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分组ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 获取分组详情（使用带加盟商权限过滤的方法）
	group, err := models.GetDeviceGroupByIdWithFranchise(id, permResult.Admin.FranchiseId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备分组详情失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取设备分组详情成功",
		"data":    group,
	}
	c.ServeJSON()
}

// Create 创建设备分组
func (c *DeviceGroupController) Create() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 解析请求参数
	var req models.DeviceGroup
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 设置加盟商ID
	req.FranchiseId = permResult.Admin.FranchiseId
	req.BeforeInsert()

	// 创建设备分组
	id, err := models.CreateDeviceGroup(&req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "创建设备分组失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "创建设备分组成功",
		"data": map[string]interface{}{
			"id": id,
		},
	}
	c.ServeJSON()
}

// Update 更新设备分组
func (c *DeviceGroupController) Update() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分组ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req models.DeviceGroup
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 更新设备分组
	req.Id = id
	req.BeforeUpdate()
	err = models.UpdateDeviceGroupWithFranchise(&req, permResult.Admin.FranchiseId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新设备分组失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "更新设备分组成功",
	}
	c.ServeJSON()
}

// Delete 删除设备分组
func (c *DeviceGroupController) Delete() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分组ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 删除设备分组（使用带加盟商权限过滤的方法）
	err = models.DeleteDeviceGroupWithFranchise(id, permResult.Admin.FranchiseId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "删除设备分组失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "删除设备分组成功",
	}
	c.ServeJSON()
}

// AddDevices 添加设备到分组
func (c *DeviceGroupController) AddDevices() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分组ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 获取分组详情（使用带加盟商权限过滤的方法）
	group, err := models.GetDeviceGroupByIdWithFranchise(id, permResult.Admin.FranchiseId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备分组详情失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req struct {
		DeviceIds []int64 `json:"device_ids"`
	}
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 添加设备到分组
	err = models.BatchAddDevicesToGroup(req.DeviceIds, group.Id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "添加设备到分组失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "添加设备到分组成功",
	}
	c.ServeJSON()
}

// RemoveDevices 从分组中移除设备
func (c *DeviceGroupController) RemoveDevices() {
	// 检查权限
	permResult := CheckControllerPermission(c.Ctx)
	if !permResult.Success {
		RespondWithError(&c.Controller, permResult)
		return
	}

	// 获取分组ID
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 获取分组详情（使用带加盟商权限过滤的方法）
	group, err := models.GetDeviceGroupByIdWithFranchise(id, permResult.Admin.FranchiseId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备分组详情失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req struct {
		DeviceIds []int64 `json:"device_ids"`
	}
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 从分组中移除设备
	err = models.BatchRemoveDevicesFromGroup(req.DeviceIds, group.Id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "从分组中移除设备失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "从分组中移除设备成功",
	}
	c.ServeJSON()
}

// GetDevices 获取分组下的设备列表
func (c *DeviceGroupController) GetDevices() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取分组ID
	id, err := c.GetInt64("group_id", -1)
	if id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的分组ID",
		}
		c.ServeJSON()
		return
	}

	// 获取分组详情
	group, err := models.GetDeviceGroupById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备分组详情失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 如果不是超级管理员，验证加盟商权限
	if !admin.IsSuper() {
		// 获取加盟商ID列表
		franchiseIds, err := models.GetFranchiseIdsByAdminId(admin.Id)
		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "获取加盟商信息失败",
			}
			c.ServeJSON()
			return
		}

		// 验证分组是否属于当前加盟商
		hasPermission := false
		for _, franchiseId := range franchiseIds {
			if group.FranchiseId == franchiseId {
				hasPermission = true
				break
			}
		}

		if !hasPermission {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "无权查看此设备分组",
			}
			c.ServeJSON()
			return
		}
	}

	// 获取分页参数
	pageStr := c.GetString("page")
	pageSizeStr := c.GetString("pageSize")

	page := 1
	pageSize := 10

	if pageStr != "" {
		page, _ = strconv.Atoi(pageStr)
	}

	if pageSizeStr != "" {
		pageSize, _ = strconv.Atoi(pageSizeStr)
	}

	// 获取分组下的设备列表
	devices, total, err := models.GetDevicesByGroupId(id, page, pageSize)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备列表失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取设备列表成功",
		"data": map[string]interface{}{
			"data":  devices,
			"total": total,
		},
	}
	c.ServeJSON()
}

// GetGroups 获取设备可用的分组列表
func (c *DeviceGroupController) GetGroups() {
	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取设备ID
	deviceIdStr := c.GetString("device_id")
	deviceId, err := strconv.ParseInt(deviceIdStr, 10, 64)
	if err != nil || deviceId <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的设备ID",
		}
		c.ServeJSON()
		return
	}

	// 获取设备详情
	device, err := models.GetDeviceById(deviceId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取设备详情失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 如果不是超级管理员，验证加盟商权限
	if !admin.IsSuper() {
		// 获取加盟商ID列表
		franchiseIds, err := models.GetFranchiseIdsByAdminId(admin.Id)
		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "获取加盟商信息失败",
			}
			c.ServeJSON()
			return
		}

		// 验证设备是否属于当前加盟商
		hasPermission := false
		for _, franchiseId := range franchiseIds {
			if device.FranchiseId == franchiseId {
				hasPermission = true
				break
			}
		}

		if !hasPermission {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "无权查看此设备的分组",
			}
			c.ServeJSON()
			return
		}
	}

	// 获取设备可用的分组列表
	groups, err := models.GetGroupsByDeviceId(deviceId)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取分组列表失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取分组列表成功",
		"data":    groups,
	}
	c.ServeJSON()
}
